home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / artskde.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-09-09  |  20.5 KB  |  605 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSKDE_H
  4. #define ARTSKDE_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "kmedia2.h"
  12. #include "artsflow.h"
  13.  
  14. namespace Arts {
  15. class KFloatWatchProxy;
  16. class KIOInputStream;
  17. class KDataRequest;
  18. class KIOTestSlow;
  19.  
  20. class ARTS_EXPORT KFloatWatchProxy_base : virtual public Arts::Object_base {
  21. public:
  22.     static unsigned long _IID; // interface ID
  23.  
  24.     static KFloatWatchProxy_base *_create(const std::string& subClass = "Arts::KFloatWatchProxy");
  25.     static KFloatWatchProxy_base *_fromString(const std::string& objectref);
  26.     static KFloatWatchProxy_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  27.  
  28.     static KFloatWatchProxy_base *_fromDynamicCast(const Arts::Object& object);
  29.     inline KFloatWatchProxy_base *_copy() {
  30.         assert(_refCnt > 0);
  31.         _refCnt++;
  32.         return this;
  33.     }
  34.  
  35.     virtual std::vector<std::string> _defaultPortsIn() const;
  36.     virtual std::vector<std::string> _defaultPortsOut() const;
  37.  
  38.     void *_cast(unsigned long iid);
  39.  
  40.     virtual float value() = 0;
  41.     virtual void value(float newValue) = 0;
  42. };
  43.  
  44. class ARTS_EXPORT KFloatWatchProxy_stub : virtual public KFloatWatchProxy_base, virtual public Arts::Object_stub {
  45. protected:
  46.     KFloatWatchProxy_stub();
  47.  
  48. public:
  49.     KFloatWatchProxy_stub(Arts::Connection *connection, long objectID);
  50.  
  51.     float value();
  52.     void value(float newValue);
  53. };
  54.  
  55. class ARTS_EXPORT KFloatWatchProxy_skel : virtual public KFloatWatchProxy_base, virtual public Arts::Object_skel {
  56. protected:
  57.     // emitters for change notifications
  58.     inline void value_changed(float newValue) {
  59.         _emit_changed("value_changed",newValue);
  60.     }
  61.  
  62. public:
  63.     KFloatWatchProxy_skel();
  64.  
  65.     static std::string _interfaceNameSkel();
  66.     std::string _interfaceName();
  67.     bool _isCompatibleWith(const std::string& interfacename);
  68.     void _buildMethodTable();
  69.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  70. };
  71.  
  72. }
  73. #include "reference.h"
  74. namespace Arts {
  75. class ARTS_EXPORT KFloatWatchProxy : public Arts::Object {
  76. private:
  77.     static Arts::Object_base* _Creator();
  78.     KFloatWatchProxy_base *_cache;
  79.     inline KFloatWatchProxy_base *_method_call() {
  80.         _pool->checkcreate();
  81.         if(_pool->base) {
  82.             _cache=(KFloatWatchProxy_base *)_pool->base->_cast(KFloatWatchProxy_base::_IID);
  83.             assert(_cache);
  84.         }
  85.         return _cache;
  86.     }
  87.  
  88. protected:
  89.     inline KFloatWatchProxy(KFloatWatchProxy_base* b) : Arts::Object(b), _cache(0) {}
  90.  
  91.  
  92. public:
  93.     typedef KFloatWatchProxy_base _base_class;
  94.  
  95.     inline KFloatWatchProxy() : Arts::Object(_Creator), _cache(0) {}
  96.     inline KFloatWatchProxy(const Arts::SubClass& s) :
  97.         Arts::Object(KFloatWatchProxy_base::_create(s.string())), _cache(0) {}
  98.     inline KFloatWatchProxy(const Arts::Reference &r) :
  99.         Arts::Object(r.isString()?(KFloatWatchProxy_base::_fromString(r.string())):(KFloatWatchProxy_base::_fromReference(r.reference(),true))), _cache(0) {}
  100.     inline KFloatWatchProxy(const Arts::DynamicCast& c) : Arts::Object(KFloatWatchProxy_base::_fromDynamicCast(c.object())), _cache(0) {}
  101.     inline KFloatWatchProxy(const KFloatWatchProxy& target) : Arts::Object(target._pool), _cache(target._cache) {}
  102.     inline KFloatWatchProxy(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  103.     inline static KFloatWatchProxy null() {return KFloatWatchProxy((KFloatWatchProxy_base*)0);}
  104.     inline static KFloatWatchProxy _from_base(KFloatWatchProxy_base* b) {return KFloatWatchProxy(b);}
  105.     inline KFloatWatchProxy& operator=(const KFloatWatchProxy& target) {
  106.         if (_pool == target._pool) return *this;
  107.         _pool->Dec();
  108.         _pool = target._pool;
  109.         _cache = target._cache;
  110.         _pool->Inc();
  111.         return *this;
  112.     }
  113.     inline KFloatWatchProxy_base* _base() {return _cache?_cache:_method_call();}
  114.  
  115.     inline float value();
  116.     inline void value(float _newValue);
  117. };
  118.  
  119. class ARTS_EXPORT KIOInputStream_base : virtual public Arts::InputStream_base {
  120. public:
  121.     static unsigned long _IID; // interface ID
  122.  
  123.     static KIOInputStream_base *_create(const std::string& subClass = "Arts::KIOInputStream");
  124.     static KIOInputStream_base *_fromString(const std::string& objectref);
  125.     static KIOInputStream_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  126.  
  127.     static KIOInputStream_base *_fromDynamicCast(const Arts::Object& object);
  128.     inline KIOInputStream_base *_copy() {
  129.         assert(_refCnt > 0);
  130.         _refCnt++;
  131.         return this;
  132.     }
  133.  
  134.     virtual std::vector<std::string> _defaultPortsIn() const;
  135.     virtual std::vector<std::string> _defaultPortsOut() const;
  136.  
  137.     void *_cast(unsigned long iid);
  138.  
  139.     virtual long bufferPackets() = 0;
  140.     virtual void bufferPackets(long newValue) = 0;
  141.     virtual bool openURL(const std::string& url) = 0;
  142.     virtual long packetSize() = 0;
  143. };
  144.  
  145. class ARTS_EXPORT KIOInputStream_stub : virtual public KIOInputStream_base, virtual public Arts::InputStream_stub {
  146. protected:
  147.     KIOInputStream_stub();
  148.  
  149. public:
  150.     KIOInputStream_stub(Arts::Connection *connection, long objectID);
  151.  
  152.     long bufferPackets();
  153.     void bufferPackets(long newValue);
  154.     bool openURL(const std::string& url);
  155.     long packetSize();
  156. };
  157.  
  158. class ARTS_EXPORT KIOInputStream_skel : virtual public KIOInputStream_base, virtual public Arts::InputStream_skel {
  159. protected:
  160.     // emitters for change notifications
  161.     inline void bufferPackets_changed(long newValue) {
  162.         _emit_changed("bufferPackets_changed",newValue);
  163.     }
  164.  
  165. public:
  166.     KIOInputStream_skel();
  167.  
  168.     static std::string _interfaceNameSkel();
  169.     std::string _interfaceName();
  170.     bool _isCompatibleWith(const std::string& interfacename);
  171.     void _buildMethodTable();
  172.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  173. };
  174.  
  175. }
  176. #include "reference.h"
  177. namespace Arts {
  178. class ARTS_EXPORT KIOInputStream : public Arts::Object {
  179. private:
  180.     static Arts::Object_base* _Creator();
  181.     KIOInputStream_base *_cache;
  182.     inline KIOInputStream_base *_method_call() {
  183.         _pool->checkcreate();
  184.         if(_pool->base) {
  185.             _cache=(KIOInputStream_base *)_pool->base->_cast(KIOInputStream_base::_IID);
  186.             assert(_cache);
  187.         }
  188.         return _cache;
  189.     }
  190.  
  191. protected:
  192.     inline KIOInputStream(KIOInputStream_base* b) : Arts::Object(b), _cache(0) {}
  193.  
  194.  
  195. public:
  196.     typedef KIOInputStream_base _base_class;
  197.  
  198.     inline KIOInputStream() : Arts::Object(_Creator), _cache(0) {}
  199.     inline KIOInputStream(const Arts::SubClass& s) :
  200.         Arts::Object(KIOInputStream_base::_create(s.string())), _cache(0) {}
  201.     inline KIOInputStream(const Arts::Reference &r) :
  202.         Arts::Object(r.isString()?(KIOInputStream_base::_fromString(r.string())):(KIOInputStream_base::_fromReference(r.reference(),true))), _cache(0) {}
  203.     inline KIOInputStream(const Arts::DynamicCast& c) : Arts::Object(KIOInputStream_base::_fromDynamicCast(c.object())), _cache(0) {}
  204.     inline KIOInputStream(const KIOInputStream& target) : Arts::Object(target._pool), _cache(target._cache) {}
  205.     inline KIOInputStream(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  206.     inline static KIOInputStream null() {return KIOInputStream((KIOInputStream_base*)0);}
  207.     inline static KIOInputStream _from_base(KIOInputStream_base* b) {return KIOInputStream(b);}
  208.     inline KIOInputStream& operator=(const KIOInputStream& target) {
  209.         if (_pool == target._pool) return *this;
  210.         _pool->Dec();
  211.         _pool = target._pool;
  212.         _cache = target._cache;
  213.         _pool->Inc();
  214.         return *this;
  215.     }
  216.     inline operator Arts::InputStream() const { return Arts::InputStream(*_pool); }
  217.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  218.     inline KIOInputStream_base* _base() {return _cache?_cache:_method_call();}
  219.  
  220.     inline bool eof();
  221.     inline long size();
  222.     inline bool seekOk();
  223.     inline long seek(long position);
  224.     inline Arts::AutoSuspendState autoSuspend();
  225.     inline void start();
  226.     inline void stop();
  227.     inline void streamInit();
  228.     inline void streamStart();
  229.     inline void streamEnd();
  230.     inline long bufferPackets();
  231.     inline void bufferPackets(long _newValue);
  232.     inline bool openURL(const std::string& url);
  233.     inline long packetSize();
  234. };
  235.  
  236. class ARTS_EXPORT KDataRequest_base : virtual public Arts::SynthModule_base {
  237. public:
  238.     static unsigned long _IID; // interface ID
  239.  
  240.     static KDataRequest_base *_create(const std::string& subClass = "Arts::KDataRequest");
  241.     static KDataRequest_base *_fromString(const std::string& objectref);
  242.     static KDataRequest_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  243.  
  244.     static KDataRequest_base *_fromDynamicCast(const Arts::Object& object);
  245.     inline KDataRequest_base *_copy() {
  246.         assert(_refCnt > 0);
  247.         _refCnt++;
  248.         return this;
  249.     }
  250.  
  251.     virtual std::vector<std::string> _defaultPortsIn() const;
  252.     virtual std::vector<std::string> _defaultPortsOut() const;
  253.  
  254.     void *_cast(unsigned long iid);
  255.  
  256.     virtual void goOn() = 0;
  257. };
  258.  
  259. class ARTS_EXPORT KDataRequest_stub : virtual public KDataRequest_base, virtual public Arts::SynthModule_stub {
  260. protected:
  261.     KDataRequest_stub();
  262.  
  263. public:
  264.     KDataRequest_stub(Arts::Connection *connection, long objectID);
  265.  
  266.     void goOn();
  267. };
  268.  
  269. class ARTS_EXPORT KDataRequest_skel : virtual public KDataRequest_base, virtual public Arts::SynthModule_skel {
  270. protected:
  271.     // variables for streams
  272.     float *left;                              // incoming stream
  273.     float *right;                             // incoming stream
  274.  
  275. public:
  276.     KDataRequest_skel();
  277.  
  278.     static std::string _interfaceNameSkel();
  279.     std::string _interfaceName();
  280.     bool _isCompatibleWith(const std::string& interfacename);
  281.     void _buildMethodTable();
  282.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  283. };
  284.  
  285. }
  286. #include "reference.h"
  287. namespace Arts {
  288. class ARTS_EXPORT KDataRequest : public Arts::Object {
  289. private:
  290.     static Arts::Object_base* _Creator();
  291.     KDataRequest_base *_cache;
  292.     inline KDataRequest_base *_method_call() {
  293.         _pool->checkcreate();
  294.         if(_pool->base) {
  295.             _cache=(KDataRequest_base *)_pool->base->_cast(KDataRequest_base::_IID);
  296.             assert(_cache);
  297.         }
  298.         return _cache;
  299.     }
  300.  
  301. protected:
  302.     inline KDataRequest(KDataRequest_base* b) : Arts::Object(b), _cache(0) {}
  303.  
  304.  
  305. public:
  306.     typedef KDataRequest_base _base_class;
  307.  
  308.     inline KDataRequest() : Arts::Object(_Creator), _cache(0) {}
  309.     inline KDataRequest(const Arts::SubClass& s) :
  310.         Arts::Object(KDataRequest_base::_create(s.string())), _cache(0) {}
  311.     inline KDataRequest(const Arts::Reference &r) :
  312.         Arts::Object(r.isString()?(KDataRequest_base::_fromString(r.string())):(KDataRequest_base::_fromReference(r.reference(),true))), _cache(0) {}
  313.     inline KDataRequest(const Arts::DynamicCast& c) : Arts::Object(KDataRequest_base::_fromDynamicCast(c.object())), _cache(0) {}
  314.     inline KDataRequest(const KDataRequest& target) : Arts::Object(target._pool), _cache(target._cache) {}
  315.     inline KDataRequest(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  316.     inline static KDataRequest null() {return KDataRequest((KDataRequest_base*)0);}
  317.     inline static KDataRequest _from_base(KDataRequest_base* b) {return KDataRequest(b);}
  318.     inline KDataRequest& operator=(const KDataRequest& target) {
  319.         if (_pool == target._pool) return *this;
  320.         _pool->Dec();
  321.         _pool = target._pool;
  322.         _cache = target._cache;
  323.         _pool->Inc();
  324.         return *this;
  325.     }
  326.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  327.     inline KDataRequest_base* _base() {return _cache?_cache:_method_call();}
  328.  
  329.     inline Arts::AutoSuspendState autoSuspend();
  330.     inline void start();
  331.     inline void stop();
  332.     inline void streamInit();
  333.     inline void streamStart();
  334.     inline void streamEnd();
  335.     inline void goOn();
  336. };
  337.  
  338. class ARTS_EXPORT KIOTestSlow_base : virtual public Arts::SynthModule_base {
  339. public:
  340.     static unsigned long _IID; // interface ID
  341.  
  342.     static KIOTestSlow_base *_create(const std::string& subClass = "Arts::KIOTestSlow");
  343.     static KIOTestSlow_base *_fromString(const std::string& objectref);
  344.     static KIOTestSlow_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  345.  
  346.     static KIOTestSlow_base *_fromDynamicCast(const Arts::Object& object);
  347.     inline KIOTestSlow_base *_copy() {
  348.         assert(_refCnt > 0);
  349.         _refCnt++;
  350.         return this;
  351.     }
  352.  
  353.     virtual std::vector<std::string> _defaultPortsIn() const;
  354.     virtual std::vector<std::string> _defaultPortsOut() const;
  355.  
  356.     void *_cast(unsigned long iid);
  357.  
  358.     virtual Arts::InputStream inputStream() = 0;
  359.     virtual void inputStream(Arts::InputStream newValue) = 0;
  360. };
  361.  
  362. class ARTS_EXPORT KIOTestSlow_stub : virtual public KIOTestSlow_base, virtual public Arts::SynthModule_stub {
  363. protected:
  364.     KIOTestSlow_stub();
  365.  
  366. public:
  367.     KIOTestSlow_stub(Arts::Connection *connection, long objectID);
  368.  
  369.     Arts::InputStream inputStream();
  370.     void inputStream(Arts::InputStream newValue);
  371. };
  372.  
  373. class ARTS_EXPORT KIOTestSlow_skel : virtual public KIOTestSlow_base, virtual public Arts::SynthModule_skel {
  374. protected:
  375.     // variables for streams
  376.     Arts::ByteAsyncStream data;               // incoming stream
  377.  
  378.     // handler for asynchronous streams
  379.     virtual void process_data(Arts::DataPacket<Arts::mcopbyte> *) = 0;
  380.  
  381. public:
  382.     KIOTestSlow_skel();
  383.  
  384.     static std::string _interfaceNameSkel();
  385.     std::string _interfaceName();
  386.     bool _isCompatibleWith(const std::string& interfacename);
  387.     void _buildMethodTable();
  388.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  389.     void notify(const Arts::Notification& notification);
  390. };
  391.  
  392. }
  393. #include "reference.h"
  394. namespace Arts {
  395. class ARTS_EXPORT KIOTestSlow : public Arts::Object {
  396. private:
  397.     static Arts::Object_base* _Creator();
  398.     KIOTestSlow_base *_cache;
  399.     inline KIOTestSlow_base *_method_call() {
  400.         _pool->checkcreate();
  401.         if(_pool->base) {
  402.             _cache=(KIOTestSlow_base *)_pool->base->_cast(KIOTestSlow_base::_IID);
  403.             assert(_cache);
  404.         }
  405.         return _cache;
  406.     }
  407.  
  408. protected:
  409.     inline KIOTestSlow(KIOTestSlow_base* b) : Arts::Object(b), _cache(0) {}
  410.  
  411.  
  412. public:
  413.     typedef KIOTestSlow_base _base_class;
  414.  
  415.     inline KIOTestSlow() : Arts::Object(_Creator), _cache(0) {}
  416.     inline KIOTestSlow(const Arts::SubClass& s) :
  417.         Arts::Object(KIOTestSlow_base::_create(s.string())), _cache(0) {}
  418.     inline KIOTestSlow(const Arts::Reference &r) :
  419.         Arts::Object(r.isString()?(KIOTestSlow_base::_fromString(r.string())):(KIOTestSlow_base::_fromReference(r.reference(),true))), _cache(0) {}
  420.     inline KIOTestSlow(const Arts::DynamicCast& c) : Arts::Object(KIOTestSlow_base::_fromDynamicCast(c.object())), _cache(0) {}
  421.     inline KIOTestSlow(const KIOTestSlow& target) : Arts::Object(target._pool), _cache(target._cache) {}
  422.     inline KIOTestSlow(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  423.     inline static KIOTestSlow null() {return KIOTestSlow((KIOTestSlow_base*)0);}
  424.     inline static KIOTestSlow _from_base(KIOTestSlow_base* b) {return KIOTestSlow(b);}
  425.     inline KIOTestSlow& operator=(const KIOTestSlow& target) {
  426.         if (_pool == target._pool) return *this;
  427.         _pool->Dec();
  428.         _pool = target._pool;
  429.         _cache = target._cache;
  430.         _pool->Inc();
  431.         return *this;
  432.     }
  433.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  434.     inline KIOTestSlow_base* _base() {return _cache?_cache:_method_call();}
  435.  
  436.     inline Arts::AutoSuspendState autoSuspend();
  437.     inline void start();
  438.     inline void stop();
  439.     inline void streamInit();
  440.     inline void streamStart();
  441.     inline void streamEnd();
  442.     inline Arts::InputStream inputStream();
  443.     inline void inputStream(Arts::InputStream _newValue);
  444. };
  445.  
  446. }
  447. // Forward wrapper calls to _base classes:
  448.  
  449. inline float Arts::KFloatWatchProxy::value()
  450. {
  451.     return _cache?static_cast<Arts::KFloatWatchProxy_base*>(_cache)->value():static_cast<Arts::KFloatWatchProxy_base*>(_method_call())->value();
  452. }
  453.  
  454. inline void Arts::KFloatWatchProxy::value(float _newValue)
  455. {
  456.      _cache?static_cast<Arts::KFloatWatchProxy_base*>(_cache)->value(_newValue):static_cast<Arts::KFloatWatchProxy_base*>(_method_call())->value(_newValue);
  457. }
  458.  
  459. inline bool Arts::KIOInputStream::eof()
  460. {
  461.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->eof():static_cast<Arts::InputStream_base*>(_method_call())->eof();
  462. }
  463.  
  464. inline long Arts::KIOInputStream::size()
  465. {
  466.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->size():static_cast<Arts::InputStream_base*>(_method_call())->size();
  467. }
  468.  
  469. inline bool Arts::KIOInputStream::seekOk()
  470. {
  471.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seekOk():static_cast<Arts::InputStream_base*>(_method_call())->seekOk();
  472. }
  473.  
  474. inline long Arts::KIOInputStream::seek(long position)
  475. {
  476.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seek(position):static_cast<Arts::InputStream_base*>(_method_call())->seek(position);
  477. }
  478.  
  479. inline Arts::AutoSuspendState Arts::KIOInputStream::autoSuspend()
  480. {
  481.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  482. }
  483.  
  484. inline void Arts::KIOInputStream::start()
  485. {
  486.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  487. }
  488.  
  489. inline void Arts::KIOInputStream::stop()
  490. {
  491.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  492. }
  493.  
  494. inline void Arts::KIOInputStream::streamInit()
  495. {
  496.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  497. }
  498.  
  499. inline void Arts::KIOInputStream::streamStart()
  500. {
  501.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  502. }
  503.  
  504. inline void Arts::KIOInputStream::streamEnd()
  505. {
  506.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  507. }
  508.  
  509. inline long Arts::KIOInputStream::bufferPackets()
  510. {
  511.     return _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->bufferPackets():static_cast<Arts::KIOInputStream_base*>(_method_call())->bufferPackets();
  512. }
  513.  
  514. inline void Arts::KIOInputStream::bufferPackets(long _newValue)
  515. {
  516.      _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->bufferPackets(_newValue):static_cast<Arts::KIOInputStream_base*>(_method_call())->bufferPackets(_newValue);
  517. }
  518.  
  519. inline bool Arts::KIOInputStream::openURL(const std::string& url)
  520. {
  521.     return _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->openURL(url):static_cast<Arts::KIOInputStream_base*>(_method_call())->openURL(url);
  522. }
  523.  
  524. inline long Arts::KIOInputStream::packetSize()
  525. {
  526.     return _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->packetSize():static_cast<Arts::KIOInputStream_base*>(_method_call())->packetSize();
  527. }
  528.  
  529. inline Arts::AutoSuspendState Arts::KDataRequest::autoSuspend()
  530. {
  531.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  532. }
  533.  
  534. inline void Arts::KDataRequest::start()
  535. {
  536.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  537. }
  538.  
  539. inline void Arts::KDataRequest::stop()
  540. {
  541.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  542. }
  543.  
  544. inline void Arts::KDataRequest::streamInit()
  545. {
  546.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  547. }
  548.  
  549. inline void Arts::KDataRequest::streamStart()
  550. {
  551.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  552. }
  553.  
  554. inline void Arts::KDataRequest::streamEnd()
  555. {
  556.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  557. }
  558.  
  559. inline void Arts::KDataRequest::goOn()
  560. {
  561.      _cache?static_cast<Arts::KDataRequest_base*>(_cache)->goOn():static_cast<Arts::KDataRequest_base*>(_method_call())->goOn();
  562. }
  563.  
  564. inline Arts::AutoSuspendState Arts::KIOTestSlow::autoSuspend()
  565. {
  566.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  567. }
  568.  
  569. inline void Arts::KIOTestSlow::start()
  570. {
  571.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  572. }
  573.  
  574. inline void Arts::KIOTestSlow::stop()
  575. {
  576.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  577. }
  578.  
  579. inline void Arts::KIOTestSlow::streamInit()
  580. {
  581.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  582. }
  583.  
  584. inline void Arts::KIOTestSlow::streamStart()
  585. {
  586.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  587. }
  588.  
  589. inline void Arts::KIOTestSlow::streamEnd()
  590. {
  591.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  592. }
  593.  
  594. inline Arts::InputStream Arts::KIOTestSlow::inputStream()
  595. {
  596.     return _cache?static_cast<Arts::KIOTestSlow_base*>(_cache)->inputStream():static_cast<Arts::KIOTestSlow_base*>(_method_call())->inputStream();
  597. }
  598.  
  599. inline void Arts::KIOTestSlow::inputStream(Arts::InputStream _newValue)
  600. {
  601.      _cache?static_cast<Arts::KIOTestSlow_base*>(_cache)->inputStream(_newValue):static_cast<Arts::KIOTestSlow_base*>(_method_call())->inputStream(_newValue);
  602. }
  603.  
  604. #endif /* ARTSKDE_H */
  605.